package edu.sandau.app.basic.controller;

import edu.sandau.app.basic.domain.DishWithBLOBs;
import edu.sandau.app.basic.golbal.GlobalEnum;
import edu.sandau.app.basic.service.DishService;
import edu.sandau.app.basic.vo.BasicMsg;
import edu.sandau.app.basic.vo.BasicMsgWithData;
import edu.sandau.app.basic.vo.CreateDishRequest;
import java.math.BigDecimal;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.ExampleObject;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.responses.ApiResponses;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/dishes")
@Tag(name = "菜品管理", description = "菜品信息管理接口")
public class DishController {
    
    @Autowired
    private DishService dishService;
    
    // 获取所有菜品
    @GetMapping
    @Operation(summary = "获取所有菜品")
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "操作成功",
            content = @Content(mediaType = "application/json", 
                examples = {
                    @ExampleObject(name = "查询成功", value = """
                        {
                          "operateResult": "SUCC",
                          "errorMsg": "查询成功",
                          "errorCode": "Ok",
                          "data": [
                            {
                              "dishName": "宫保鸡丁",
                              "dishType": "川菜",
                              "dishPrice": 28.00,
                              "dishImage": "http://example.com/image1.jpg",
                              "dishSpecification": "中份",
                              "dishStatus": "0",
                              "salesCount": 150,
                              "remark": "经典川菜",
                              "dishDescription": "鸡肉丁配花生米，麻辣鲜香",
                              "dishMaterials": "鸡肉、花生米、干辣椒、花椒"
                            },
                            {
                              "dishName": "麻婆豆腐",
                              "dishType": "川菜",
                              "dishPrice": 18.00,
                              "dishImage": "http://example.com/image2.jpg",
                              "dishSpecification": "中份",
                              "dishStatus": "0",
                              "salesCount": 200,
                              "remark": "经典川菜",
                              "dishDescription": "嫩豆腐配肉末，麻辣鲜香",
                              "dishMaterials": "嫩豆腐、猪肉末、豆瓣酱、花椒"
                            }
                          ]
                        }"""),
                    @ExampleObject(name = "暂无菜品", value = """
                        {
                          "operateResult": "SUCC",
                          "errorMsg": "查询成功",
                          "errorCode": "Ok",
                          "data": []
                        }"""),
                    @ExampleObject(name = "查询失败", value = """
                        {
                          "operateResult": "UNSUSS",
                          "errorMsg": "查询失败: 数据库连接异常",
                          "errorCode": "DISH_QUERY_FAIL",
                          "data": null
                        }""")
                }))
    })
    public BasicMsgWithData<List<DishWithBLOBs>> getAllDishes() {
        BasicMsgWithData<List<DishWithBLOBs>> msg = new BasicMsgWithData<>();
        try {
            List<DishWithBLOBs> dishes = dishService.getAllDishes();
            msg.setErrorCode(GlobalEnum.ErrorCode.Ok);
            msg.setErrorMsg("查询成功");
            msg.setOperateResult(GlobalEnum.OperateResult.SUCC);
            msg.setData(dishes);
        } catch (Exception e) {
            msg.setErrorCode(GlobalEnum.ErrorCode.DISH_QUERY_FAIL);
            msg.setErrorMsg("查询失败: " + e.getMessage());
            msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
        }
        return msg;
    }
    
    // 根据ID获取菜品
    @GetMapping("/{id}")
    @Operation(summary = "根据ID获取菜品")
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "操作成功",
            content = @Content(mediaType = "application/json", 
                examples = {
                    @ExampleObject(name = "查询成功", value = """
                        {
                          "operateResult": "SUCC",
                          "errorMsg": "查询成功",
                          "errorCode": "Ok",
                          "data": {
                            "dishId": 1,
                            "dishName": "宫保鸡丁",
                            "dishType": "川菜",
                            "dishPrice": 28.00,
                            "dishImage": "http://example.com/image.jpg",
                            "dishDescription": "经典川菜",
                            "dishSpecification": "中份",
                            "dishMaterials": "鸡肉、花生、辣椒",
                            "dishStatus": "0",
                            "salesCount": 100
                          }
                        }"""),
                    @ExampleObject(name = "菜品不存在", value = """
                        {
                          "operateResult": "UNSUSS",
                          "errorMsg": "菜品不存在",
                          "errorCode": "DISH_NOT_FOUND",
                          "data": null
                        }""")
                }))
    })
    public BasicMsgWithData<DishWithBLOBs> getDishById(@PathVariable Long id) {
        BasicMsgWithData<DishWithBLOBs> msg = new BasicMsgWithData<>();
        try {
            DishWithBLOBs dish = dishService.getDishById(id);
            if (dish != null) {
                msg.setErrorCode(GlobalEnum.ErrorCode.Ok);
                msg.setErrorMsg("查询成功");
                msg.setOperateResult(GlobalEnum.OperateResult.SUCC);
                msg.setData(dish);
            } else {
                msg.setErrorCode(GlobalEnum.ErrorCode.DISH_NOT_FOUND);
                msg.setErrorMsg("菜品不存在");
                msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
            }
        } catch (Exception e) {
            msg.setErrorCode(GlobalEnum.ErrorCode.DISH_QUERY_FAIL);
            msg.setErrorMsg("查询失败: " + e.getMessage());
            msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
        }
        return msg;
    }
    
    // 创建菜品
    @PostMapping
    @Operation(summary = "创建菜品")
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "操作完成",
            content = @Content(mediaType = "application/json",
                examples = {
                    @ExampleObject(name = "创建成功", value = """
                        {
                          "operateResult": "SUCC",
                          "errorMsg": "菜品创建成功",
                          "errorCode": "Ok"
                        }"""),
                    @ExampleObject(name = "创建失败", value = """
                        {
                          "operateResult": "UNSUSS",
                          "errorMsg": "菜品创建失败",
                          "errorCode": "DISH_ADD_FAIL"
                        }""")
                }))
    })
    public BasicMsg addDish(@RequestBody CreateDishRequest request) {
        BasicMsg msg = new BasicMsg();
        try {
            // 验证必需字段
            if (request.getDishName() == null || request.getDishName().trim().isEmpty()) {
                msg.setErrorCode(GlobalEnum.ErrorCode.DISH_ADD_FAIL);
                msg.setErrorMsg("菜品名称不能为空");
                msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
                return msg;
            }
            if (request.getDishPrice() == null) {
                msg.setErrorCode(GlobalEnum.ErrorCode.DISH_ADD_FAIL);
                msg.setErrorMsg("菜品价格不能为空");
                msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
                return msg;
            }
            
            // 验证数值字段和枚举字段，收集所有错误
            StringBuilder validationErrors = new StringBuilder();
            
            // 验证菜品价格必须大于等于0
            if (request.getDishPrice() != null && request.getDishPrice().compareTo(BigDecimal.ZERO) < 0) {
                validationErrors.append("菜品价格不能小于0; ");
            }
            
            // 验证销售数量必须大于等于0
            if (request.getSalesCount() != null && request.getSalesCount() < 0) {
                validationErrors.append("销售数量不能小于0; ");
            }
            
            // 验证菜品状态枚举值
            if (request.getDishStatus() != null && !request.getDishStatus().trim().isEmpty()) {
                if (!"0".equals(request.getDishStatus()) && !"1".equals(request.getDishStatus())) {
                    validationErrors.append("菜品状态字段值无效，只能是：0=正常, 1=停售; ");
                }
            }
            
            // 如果有验证错误，返回所有错误
            if (validationErrors.length() > 0) {
                msg.setErrorCode(GlobalEnum.ErrorCode.DISH_ADD_FAIL);
                msg.setErrorMsg(validationErrors.toString().trim());
                msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
                return msg;
            }
            
            // 创建 DishWithBLOBs 对象
            DishWithBLOBs dish = new DishWithBLOBs();
            dish.setDishName(request.getDishName());
            dish.setDishType(request.getDishType());
            dish.setDishPrice(request.getDishPrice());
            dish.setDishImage(request.getDishImage());
            dish.setDishSpecification(request.getDishSpecification());
            dish.setDishStatus(request.getDishStatus());
            dish.setSalesCount(request.getSalesCount());
            dish.setRemark(request.getRemark());
            dish.setDishDescription(request.getDishDescription());
            dish.setDishMaterials(request.getDishMaterials());
            
            int result = dishService.addDish(dish);
            if (result > 0) {
                msg.setErrorCode(GlobalEnum.ErrorCode.Ok);
                msg.setErrorMsg("菜品创建成功");
                msg.setOperateResult(GlobalEnum.OperateResult.SUCC);
            } else {
                msg.setErrorCode(GlobalEnum.ErrorCode.DISH_ADD_FAIL);
                msg.setErrorMsg("菜品创建失败");
                msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
            }
        } catch (Exception e) {
            msg.setErrorCode(GlobalEnum.ErrorCode.DISH_ADD_FAIL);
            msg.setErrorMsg("菜品创建失败: " + e.getMessage());
            msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
        }
        return msg;
    }
    
    // 更新菜品
    @PutMapping("/{id}")
    @Operation(summary = "更新菜品")
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "操作完成",
            content = @Content(mediaType = "application/json",
                examples = {
                    @ExampleObject(name = "更新成功", value = """
                        {
                          "operateResult": "SUCC",
                          "errorMsg": "菜品更新成功",
                          "errorCode": "Ok"
                        }"""),
                    @ExampleObject(name = "菜品名称不能为空", value = """
                        {
                          "operateResult": "UNSUSS",
                          "errorMsg": "菜品名称不能为空",
                          "errorCode": "DISH_MODIFY_FAIL"
                        }"""),
                    @ExampleObject(name = "菜品价格不能为空", value = """
                        {
                          "operateResult": "UNSUSS",
                          "errorMsg": "菜品价格不能为空",
                          "errorCode": "DISH_MODIFY_FAIL"
                        }"""),
                    @ExampleObject(name = "数值验证失败", value = """
                        {
                          "operateResult": "UNSUSS",
                          "errorMsg": "菜品价格不能小于0; 销售数量不能小于0",
                          "errorCode": "DISH_MODIFY_FAIL"
                        }"""),
                    @ExampleObject(name = "枚举值无效", value = """
                        {
                          "operateResult": "UNSUSS",
                          "errorMsg": "菜品状态字段值无效，只能是：0=正常, 1=停售",
                          "errorCode": "DISH_MODIFY_FAIL"
                        }"""),
                    @ExampleObject(name = "更新失败", value = """
                        {
                          "operateResult": "UNSUSS",
                          "errorMsg": "菜品更新失败",
                          "errorCode": "DISH_MODIFY_FAIL"
                        }""")
                }))
    })
    public BasicMsg updateDish(@PathVariable Long id, @RequestBody DishWithBLOBs dish) {
        BasicMsg msg = new BasicMsg();
        try {
            // 验证必需字段
            if (dish.getDishName() == null || dish.getDishName().trim().isEmpty()) {
                msg.setErrorCode(GlobalEnum.ErrorCode.DISH_MODIFY_FAIL);
                msg.setErrorMsg("菜品名称不能为空");
                msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
                return msg;
            }
            if (dish.getDishPrice() == null) {
                msg.setErrorCode(GlobalEnum.ErrorCode.DISH_MODIFY_FAIL);
                msg.setErrorMsg("菜品价格不能为空");
                msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
                return msg;
            }
            
            // 验证数值字段和枚举字段，收集所有错误
            StringBuilder validationErrors = new StringBuilder();
            
            // 验证菜品价格必须大于等于0
            if (dish.getDishPrice() != null && dish.getDishPrice().compareTo(BigDecimal.ZERO) < 0) {
                validationErrors.append("菜品价格不能小于0; ");
            }
            
            // 验证销售数量必须大于等于0
            if (dish.getSalesCount() != null && dish.getSalesCount() < 0) {
                validationErrors.append("销售数量不能小于0; ");
            }
            
            // 验证菜品状态枚举值
            if (dish.getDishStatus() != null && !dish.getDishStatus().trim().isEmpty()) {
                if (!"0".equals(dish.getDishStatus()) && !"1".equals(dish.getDishStatus())) {
                    validationErrors.append("菜品状态字段值无效，只能是：0=正常, 1=停售; ");
                }
            }
            
            // 如果有验证错误，返回所有错误
            if (validationErrors.length() > 0) {
                msg.setErrorCode(GlobalEnum.ErrorCode.DISH_MODIFY_FAIL);
                msg.setErrorMsg(validationErrors.toString().trim());
                msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
                return msg;
            }
            
            // 设置要更新的菜品ID，系统时间字段由服务层处理
            dish.setDishId(id);
            dish.setCreateTime(null); // 创建时间不允许更新
            dish.setUpdateTime(null); // 更新时间由服务层自动设置
            
            int result = dishService.updateDish(dish);
            if (result > 0) {
                msg.setErrorCode(GlobalEnum.ErrorCode.Ok);
                msg.setErrorMsg("菜品更新成功");
                msg.setOperateResult(GlobalEnum.OperateResult.SUCC);
            } else {
                msg.setErrorCode(GlobalEnum.ErrorCode.DISH_MODIFY_FAIL);
                msg.setErrorMsg("菜品更新失败");
                msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
            }
        } catch (Exception e) {
            msg.setErrorCode(GlobalEnum.ErrorCode.DISH_MODIFY_FAIL);
            msg.setErrorMsg("菜品更新失败: " + e.getMessage());
            msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
        }
        return msg;
    }
    
    // 删除菜品
    @DeleteMapping("/{id}")
    @Operation(summary = "删除菜品")
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "操作完成",
            content = @Content(mediaType = "application/json",
                examples = {
                    @ExampleObject(name = "删除成功", value = """
                        {
                          "operateResult": "SUCC",
                          "errorMsg": "菜品删除成功",
                          "errorCode": "Ok"
                        }"""),
                    @ExampleObject(name = "删除失败", value = """
                        {
                          "operateResult": "UNSUSS",
                          "errorMsg": "菜品删除失败",
                          "errorCode": "DISH_DELETE_FAIL"
                        }"""),
                    @ExampleObject(name = "菜品不存在", value = """
                        {
                          "operateResult": "UNSUSS",
                          "errorMsg": "菜品删除失败: 菜品不存在",
                          "errorCode": "DISH_DELETE_FAIL"
                        }""")
                }))
    })
    public BasicMsg deleteDish(@PathVariable Long id) {
        BasicMsg msg = new BasicMsg();
        try {
            int result = dishService.deleteDish(id);
            if (result > 0) {
                msg.setErrorCode(GlobalEnum.ErrorCode.Ok);
                msg.setErrorMsg("菜品删除成功");
                msg.setOperateResult(GlobalEnum.OperateResult.SUCC);
            } else {
                msg.setErrorCode(GlobalEnum.ErrorCode.DISH_DELETE_FAIL);
                msg.setErrorMsg("菜品删除失败");
                msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
            }
        } catch (Exception e) {
            msg.setErrorCode(GlobalEnum.ErrorCode.DISH_DELETE_FAIL);
            msg.setErrorMsg("菜品删除失败: " + e.getMessage());
            msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
        }
        return msg;
    }
    
    // 根据菜品类型查询
    @GetMapping("/type/{type}")
    @Operation(summary = "根据菜品类型查询")
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "操作成功",
            content = @Content(mediaType = "application/json", 
                examples = {
                    @ExampleObject(name = "查询成功", value = """
                        {
                          "operateResult": "SUCC",
                          "errorMsg": "查询成功",
                          "errorCode": "Ok",
                          "data": [
                            {
                              "dishName": "宫保鸡丁",
                              "dishType": "川菜",
                              "dishPrice": 28.00,
                              "dishImage": "http://example.com/image1.jpg",
                              "dishSpecification": "中份",
                              "dishStatus": "0",
                              "salesCount": 150,
                              "remark": "经典川菜",
                              "dishDescription": "鸡肉丁配花生米，麻辣鲜香",
                              "dishMaterials": "鸡肉、花生米、干辣椒、花椒"
                            }
                          ]
                        }"""),
                    @ExampleObject(name = "该类型无菜品", value = """
                        {
                          "operateResult": "UNSUSS",
                          "errorMsg": "未找到该类型的菜品",
                          "errorCode": "DISH_NOT_FOUND",
                          "data": null
                        }"""),
                    @ExampleObject(name = "查询失败", value = """
                        {
                          "operateResult": "UNSUSS",
                          "errorMsg": "查询失败: 数据库连接异常",
                          "errorCode": "DISH_QUERY_FAIL",
                          "data": null
                        }""")
                }))
    })
    public BasicMsgWithData<List<DishWithBLOBs>> getDishesByType(@PathVariable String type) {
        BasicMsgWithData<List<DishWithBLOBs>> msg = new BasicMsgWithData<>();
        try {
            List<DishWithBLOBs> dishes = dishService.getDishesByType(type);
            if (dishes != null && !dishes.isEmpty()) {
                msg.setErrorCode(GlobalEnum.ErrorCode.Ok);
                msg.setErrorMsg("查询成功");
                msg.setOperateResult(GlobalEnum.OperateResult.SUCC);
                msg.setData(dishes);
            } else {
                msg.setErrorCode(GlobalEnum.ErrorCode.DISH_NOT_FOUND);
                msg.setErrorMsg("未找到该类型的菜品");
                msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
                msg.setData(null);
            }
        } catch (Exception e) {
            msg.setErrorCode(GlobalEnum.ErrorCode.DISH_QUERY_FAIL);
            msg.setErrorMsg("查询失败: " + e.getMessage());
            msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
            msg.setData(null);
        }
        return msg;
    }
    
    // 根据菜品名称模糊查询
    @GetMapping("/name/{name}")
    @Operation(summary = "根据菜品名称模糊查询")
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "操作成功",
            content = @Content(mediaType = "application/json", 
                examples = {
                    @ExampleObject(name = "查询成功", value = """
                        {
                          "operateResult": "SUCC",
                          "errorMsg": "查询成功",
                          "errorCode": "Ok",
                          "data": [
                            {
                              "dishName": "宫保鸡丁",
                              "dishType": "川菜",
                              "dishPrice": 28.00,
                              "dishImage": "http://example.com/image1.jpg",
                              "dishSpecification": "中份",
                              "dishStatus": "0",
                              "salesCount": 150,
                              "remark": "经典川菜",
                              "dishDescription": "鸡肉丁配花生米，麻辣鲜香",
                              "dishMaterials": "鸡肉、花生米、干辣椒、花椒"
                            }
                          ]
                        }"""),
                    @ExampleObject(name = "未找到匹配菜品", value = """
                        {
                          "operateResult": "UNSUSS",
                          "errorMsg": "未找到匹配的菜品",
                          "errorCode": "DISH_NOT_FOUND",
                          "data": null
                        }"""),
                    @ExampleObject(name = "查询失败", value = """
                        {
                          "operateResult": "UNSUSS",
                          "errorMsg": "查询失败: 数据库连接异常",
                          "errorCode": "DISH_QUERY_FAIL",
                          "data": null
                        }""")
                }))
    })
    public BasicMsgWithData<List<DishWithBLOBs>> getDishesByName(@PathVariable String name) {
        BasicMsgWithData<List<DishWithBLOBs>> msg = new BasicMsgWithData<>();
        try {
            List<DishWithBLOBs> dishes = dishService.getDishesByName(name);
            if (dishes != null && !dishes.isEmpty()) {
                msg.setErrorCode(GlobalEnum.ErrorCode.Ok);
                msg.setErrorMsg("查询成功");
                msg.setOperateResult(GlobalEnum.OperateResult.SUCC);
                msg.setData(dishes);
            } else {
                msg.setErrorCode(GlobalEnum.ErrorCode.DISH_NOT_FOUND);
                msg.setErrorMsg("未找到匹配的菜品");
                msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
                msg.setData(null);
            }
        } catch (Exception e) {
            msg.setErrorCode(GlobalEnum.ErrorCode.DISH_QUERY_FAIL);
            msg.setErrorMsg("查询失败: " + e.getMessage());
            msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
            msg.setData(null);
        }
        return msg;
    }
    
    // 获取正常销售的菜品
    @GetMapping("/available")
    @Operation(summary = "获取正常销售的菜品")
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "操作成功",
            content = @Content(mediaType = "application/json", 
                examples = {
                    @ExampleObject(name = "查询成功", value = """
                        {
                          "operateResult": "SUCC",
                          "errorMsg": "查询成功",
                          "errorCode": "Ok",
                          "data": [
                            {
                              "dishName": "宫保鸡丁",
                              "dishType": "川菜",
                              "dishPrice": 28.00,
                              "dishImage": "http://example.com/image1.jpg",
                              "dishSpecification": "中份",
                              "dishStatus": "0",
                              "salesCount": 150,
                              "remark": "经典川菜",
                              "dishDescription": "鸡肉丁配花生米，麻辣鲜香",
                              "dishMaterials": "鸡肉、花生米、干辣椒、花椒"
                            }
                          ]
                        }"""),
                    @ExampleObject(name = "暂无可售菜品", value = """
                        {
                          "operateResult": "UNSUSS",
                          "errorMsg": "暂无可售菜品",
                          "errorCode": "DISH_NOT_FOUND",
                          "data": null
                        }"""),
                    @ExampleObject(name = "查询失败", value = """
                        {
                          "operateResult": "UNSUSS",
                          "errorMsg": "查询失败: 数据库连接异常",
                          "errorCode": "DISH_QUERY_FAIL",
                          "data": null
                        }""")
                }))
    })
    public BasicMsgWithData<List<DishWithBLOBs>> getAvailableDishes() {
        BasicMsgWithData<List<DishWithBLOBs>> msg = new BasicMsgWithData<>();
        try {
            List<DishWithBLOBs> dishes = dishService.getAvailableDishes();
            if (dishes != null && !dishes.isEmpty()) {
                msg.setErrorCode(GlobalEnum.ErrorCode.Ok);
                msg.setErrorMsg("查询成功");
                msg.setOperateResult(GlobalEnum.OperateResult.SUCC);
                msg.setData(dishes);
            } else {
                msg.setErrorCode(GlobalEnum.ErrorCode.DISH_NOT_FOUND);
                msg.setErrorMsg("暂无可售菜品");
                msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
                msg.setData(null);
            }
        } catch (Exception e) {
            msg.setErrorCode(GlobalEnum.ErrorCode.DISH_QUERY_FAIL);
            msg.setErrorMsg("查询失败: " + e.getMessage());
            msg.setOperateResult(GlobalEnum.OperateResult.UNSUSS);
            msg.setData(null);
        }
        return msg;
    }
}
